/**
 * 功能：获取非行间样式
 * @param {element} elem 元素
 * @param {string} attr 样式名
 * @returns 获取的非行间样式
 */
function getStyle(elem, attr){
    if(elem.currentStyle){
        // 在IE中
        // .后边跟的是变量，使用[]代替
        var w = elem.currentStyle[attr];
    }else{
        // 在标准
        var w = getComputedStyle(elem)[attr];
    }
    // 返回需要的内容
    return w;
}
/**
 * 运动函数
 * @param {*} elem 运动元素
 * @param {*} attr 运动属性
 * @param {*} step 步长
 * @param {*} target 目标值
 */
// var timer = null; // 必须是全局变量  破坏了函数的整体性、封装性
function move(elem, attr, step, target){
    // 6.判断步长正负值  (当前值 < 目标值 ? 正值 : 负值)
    var cur = parseInt( getStyle(elem, attr) );
    cur<target ? step = step : step = -step;

    // 5.定时器开启之前先清除
    clearInterval(elem.timer);

    // 7.把定时器作为元素的自定义属性添加
    elem.timer = setInterval(function(){
        // 3.计算运动值：开始 - 步长
        var l = parseInt( getStyle(elem, attr) ) + step;

        // 4.到达目标值，停止运动
        if( (step>0 && l>=target) || (step<0 && l<=target) ){
            l = target;
            clearInterval(elem.timer);
        }

        // 2.元素移动位置
        // .后边跟的是变量，使用[]代替
        elem.style[attr] = l + 'px';
    }, 30);
}
/**
 * 封装一个获取max-min之间的随机数
 * @param {number} min 最小值
 * @param {number} max 最大值
 * @returns 随机数
 */
function getRandom(min, max){ // min-最小值 max-最大值
    var n = Math.floor( Math.random() * (max-min+1) + min);
    // 返回需要的内容
    return n;
}
/**
 * 获取四位随机验证码
 * @returns 验证码
 */
function getCode(){
    var str = '1234567890qwertyuiopasdfghjklzxcvbnmQWERTYUIOPASDFGHJKLZXCVBNM';
    var code = ''; // 随机验证码
    // str[随机下标]   0 -  str.length-1
    for(var i = 1; i<=4; i++){
        var x = getRandom(0, str.length -1);
        // 拼接到code上
        code += str[x];
    }
    // 返回需要的内容
    return code;
}
// 补零的函数
function fullZero(n){
    var temp = n >= 10 ? n : '0' + n;
    // 返回处理好的内容
    return temp;
}
/**
 * 封装一个绑定事件的函数
 * @param {element} elem 元素
 * @param {string} type 事件类型
 * @param {function} fun 事件处理函数
 */
function bind(elem, type, fun){
    if( elem.addEventListener ){
        // 在标准
        elem.addEventListener(type, fun);
    }else{
        // 在IE
        elem.attachEvent('on'+type, fun);
    }
}
// 取消事件的函数
function unbind(elem, type, fun){ // elem-元素 type-事件类型 fun-取消的事件
    if( elem.removeEventListener ){
        elem.removeEventListener(type, fun);
    }else{
        elem.detachEvent('on'+type, fun);
    }
}
/**
 * 封装一个滚轮事件
 * @param {element} elem 添加事件的元素
 * @param {function} upfun 向上滚动的处理函数
 * @param {function} downfun 向下滚动的处理函数
 */
function wheel(elem, upfun, downfun){// elem-添加事件的元素
    // chrome、IE的添加
    elem.onmousewheel = scroll;
    // ff的添加
    if(elem.addEventListener){
        elem.addEventListener('DOMMouseScroll', scroll);
    }

    function scroll(){
        // 根据滚动方向进行对应操作
        var tag; // true ->上  false->下
        if( event.wheelDelta ){
            // chrome IE： 上120  下-120
            event.wheelDelta > 0 ? tag = true : tag = false;
        }else{
            // ff：上-3  下3
            event.detail > 0 ? tag = false : tag = true;
        }

        // 根据tag的结果处理
        if(tag){
            // 向上滚动
            upfun(); // 实参传进来是一个函数，实参对新参赋值
        }else{
            // 向下滚动
            downfun();
        }
    }
}
/**
 * 缓冲运动
 * @param {element} elem 运动元素
 * @param {object} json 运动属性和目标值
 * @param {number} xs 缩放系数
 * @param {function} callback 可选，回调函数
 */
function bufferMove(elem, json, xs, callback) { // elem-运动元素 xs-缩放系数 callback-回调函数
    // 5.先清除之前的，再开启新的
    clearInterval(elem.timer);

    // 6.把timer作为运动元素的自定义属性添加
    elem.timer = setInterval(function () {
        // a.假设：全部到达目标
        var tag = true;

        // 在一个定时器中，运动多个属性
        for (var attr in json) { // attr-运动属性 json[attr]-目标值
            // 4.计算步长：(目标值-当前值)/缩放系数
            if (attr == 'opacity') {
                // 对于透明度放大100倍处理
                var cur = parseInt(getStyle(elem, attr) * 100); // 当前值
            } else {
                var cur = parseInt(getStyle(elem, attr));
            }

            // 前进：向上取整  后退：向下取整
            var step = (json[attr] - cur) / xs;
            step = step > 0 ? Math.ceil(step) : Math.floor(step);

            // 2.计算运动值: 原来+步长
            var l = cur + step;

            // 1.运动元素  .后边是变量使用[]代替
            if (attr == 'opacity') {
                // 透明度最后除以100
                elem.style[attr] = l / 100;
            } else {
                elem.style[attr] = l + 'px';
            }

            // b.挨个验证：运动值!=目标值
            if( l != json[attr] ){
                // 没有到达目标
                tag = false;
            }
        }
    
        // c.根据结果
        if(tag){ // 全部到达目标
            clearInterval(elem.timer);
            // 回调函数作为可选值
            // if(callback){ callback(); }
            callback && callback();
        }
    }, 50);
}
/**
 * 防抖函数
 * @param {*} fun 
 * @param {*} wait 
 * @returns 
 */
function debounce(fun, wait){ // fun-需要防抖处理的函数 wait-等待时间
    var timer = null;

    // 通过闭包模拟全局变量
    return function(){
        // 清除定时器
        clearTimeout(timer);
        timer = setTimeout(function(){
            fun();
        }, wait);
    }
}


/**
 * 当前时间的函数
 * @returns 
 */
function getTime() {
         var date = new Date();
         h < 10 ? '0' + h : h;
         var h = date.getHours(); // 小时
         var min = date.getMinutes(); // 分钟
         var s = date.getSeconds(); // 秒数
         min = min < 10 ? '0' + min : min;
         return h + ':' + min;
    }